<?php
/**
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2021/11/22
 * Time: 13:00
 */

namespace phpfuntions\mp_array;

//数组操作类 函数
class myphp_Array_operate
{
    /**
     * array_chunk 函数 ：将一个数组分割成多个数组
     * @access public
     * @return
     */
    public static function array_chunk (array $input, $size, $preserve_keys = null){
        return array_chunk( $input, $size, $preserve_keys);
    }
    /**
     * array_count_values 函数 ：统计数组中所有的值出现的次数
     * @access public
     * @return
     */
    public static function array_count_values (array $input){
        return array_count_values($input);
    }
    /**
     * array_diff_assoc 函数 ：带索引检查计算数组的差集
     * @access public
     * @return
     */
    public static function array_diff_assoc (array $array1, array $array2, array $_ = null){
        return array_diff_assoc( $array1,  $array2,  $_ );
    }
    /**
     * array_diff_key 函数 ：使用键名比较计算数组的差集
     * @access public
     * @return
     */
    public static function array_diff_key (array $array1, array $array2, array $_ = null){
        return array_diff_key($array1,  $array2,  $_ );
    }
    /**
     * array_diff_uassoc 函数 ：用回调 函数 做索引检查来计算数组的差集
     * @access public
     * @return
     */
    public static function array_diff_uassoc (array $array1, array $array2, array $_ = null, $key_compare_func){
        return array_diff_uassoc( $array1,  $array2,  $_ , $key_compare_func);
    }
    /**
     * array_diff_ukey 函数 ：用回调 函数 对键名比较计算数组的差集
     * @access public
     * @return
     */
    public static function array_diff_ukey (array $array1, array $array2, array $_ = null, $key_compare_func){
        return array_diff_ukey( $array1,  $array2,  $_ , $key_compare_func);
    }
    /**
     * array_diff 函数 ：计算数组的差集
     * @access public
     * @return
     */
    public static function array_diff (array $array1, array $array2, array $_ = null){
        return array_diff( $array1,  $array2,  $_);
    }
    /**
     * array_fill 函数 ：用给定的值填充数组
     * @access public
     * @return
     */
    public static function array_fill ($start_index, $num, $value){
        return array_fill( $start_index, $num, $value);
    }
    /**
     * array_filter 函数 ：用回调 函数 过滤数组中的单元
     * @access public
     * @return
     */
    public static function array_filter (array $input, $callback = null, $flag = 0){
        return array_filter( $input, $callback , $flag);
    }
    /**
     * array_flip 函数 ：交换数组中的键和值
     * @access public
     * @return
     */
    public static function array_flip (array $array){
        return array_flip( $array);
    }
    /**
     * array_intersect_assoc 函数 ：带索引检查计算数组的交集
     * @access public
     * @return
     */
    public static function array_intersect_assoc (array $array1, array $array2, array $_ = null){
        return array_intersect_assoc( $array1, $array2, $_);
    }
    /**
     * array_intersect_key 函数 ：使用键名比较计算数组的交集
     * @access public
     * @return
     */
    public static function array_intersect_key (array $array1, array $array2, array $_ = null){
        return array_intersect_key($array1, $array2, $_);
    }
    /**
     * array_intersect_uassoc 函数 ：带索引检查计算数组的交集，并用回调 函数 比较索引
     * @access public
     * @return
     */
    public static function array_intersect_uassoc (array $array1, array $array2, array $_ = null, $key_compare_func){
        return array_intersect_uassoc( $array1, $array2, $_ , $key_compare_func);
    }
    /**
     * array_intersect_ukey 函数 ：用回调 函数 比较键名来计算数组的交集
     * @access public
     * @return
     */
    public static function array_intersect_ukey (array $array1, array $array2, array $_ = null, $key_compare_func){
        return array_intersect_ukey( $array1, $array2, $_ , $key_compare_func);
    }
    /**
     * array_intersect 函数 ：计算数组的交集
     * @access public
     * @return
     */
    public static function array_intersect (array $array1, array $array2, array $_ = null){
        return array_intersect( $array1, $array2, $_ );
    }
    /**
     * array_key_exists 函数 ：检查给定的键名或索引是否存在于数组中
     * @access public
     * @return
     */
    public static function array_key_exists ($key, array $search){
        return array_key_exists( $key, $search);
    }
    /**
     * array_map 函数 ：将回调 函数 作用到给定数组的单元上
     * @access public
     * @return
     */
    public static function array_map ($callback, array $arr1, array $_ = null){
        return array_map( $callback, $arr1, $_ );
    }
    /**
     * array_merge_recursive 函数 ：递归地合并一个或多个数组
     * @access public
     * @return
     */
    public static function array_merge_recursive (array $array1, array $_ = null){
        return array_merge_recursive( $array1, $_ = null);
    }
    /**
     * range 函数 ：array_merge 函数 ：合并一个或多个数组　
     * @access public
     * @return
     */
    public static function array_merge (array $array1, array $array2 = null, array $_ = null){
        return array_merge( $array1, $array2 , $_);
    }

    /**
     * array_pad 函数 ：用值将数组填补到指定长度
     * @access public
     * @return
     */
    public static function array_pad (array $input, $pad_size, $pad_value){
        return array_pad( $input, $pad_size, $pad_value);
    }
    /**
     * array_pop 函数 ：将数组的最后一个单元弹出
     * @access public
     * @return
     */
    public static function array_pop (array &$array){
        return array_pop( $array);
    }
    /**
     * array_push 函数 ：将一个或多个单元压入数组的末尾
     * @access public
     * @return
     */
    public static function array_push (array &$array, $var, $_ = null){
        return array_push( $array, $var, $_);
    }
    /**
     * array_rand 函数 ：从数组中随机取出一个或多个单元
     * @access public
     * @return
     */
    public static function array_rand (array $input, $num_req = null){
        return array_rand( $input, $num_req );
    }
    /**
     * array_reduce 函数 ：用回调 函数 迭代地将数组简化为单一的值
     * @access public
     * @return
     */
    public static function array_reduce (array $input, $function, $initial = null){
        return array_reduce( $input, $function, $initial);
    }
    /**
     * array_search 函数 ：在数组中查找给定的值并返回相应的键名
     * @access public
     * @return
     */
    public static function array_search ($needle, array $haystack, $strict = null){
        return array_search( $needle,  $haystack, $strict );
    }
    /**
     * array_shift 函数 ：移除数组开头的一个单元
     * @access public
     * @return
     */
    public static function array_shift (array &$array){
        return array_shift( $array);
    }
    /**
     * array_unique 函数 ：移除数组中重复的值
     * @access public
     * @return
     */
    public static function array_unique (array $array, $sort_flags = SORT_STRING){
        return array_unique( $array, $sort_flags);
    }
    /**
     * array_unshift 函数 ：在数组开头插入一个或多个单元
     * @access public
     * @return
     */
    public static function array_unshift (array &$array, $var, $_ = null){
        return array_unshift( $array, $var, $_);
    }
    /**
     * array_slice 函数 ：从数组中取出一段
     * @access public
     * @return
     */
    public static function array_slice (array $array, $offset, $length = null, $preserve_keys = false){
        return array_slice( $array, $offset, $length, $preserve_keys);
    }
    /**
     * range 函数 ：array_splice 函数 ：把数组中的一部分去掉并用其他值取代　
     * @access public
     * @return
     */
    public static function array_splice (array &$input, $offset, $length = null, $replacement = null){
        return array_splice( $input, $offset, $length, $replacement);
    }
    /**
     * array_sum 函数 ：计算数组中所有值的和
     * @access public
     * @return
     */
    public static function array_sum (array $array){
        return array_sum( $array);
    }
    /**
     * array_uintersect_assoc 函数 ：带索引检查计算数组的交集并用回调 函数 比较数据
     * @access public
     * @return
     */
    public static function array_uintersect_assoc (array $array1, array $array2, array $_ = null, $data_compare_func){
        return array_uintersect_assoc( $array1, $array2, $_ , $data_compare_func);
    }
    /**
     * array_uintersect_uassoc 函数 ：带索引检查计算数组的交集并用回调 函数 比较数据和索引
     * @access public
     * @return
     */
    public static function array_uintersect_uassoc (array $array1, array $array2, array $_ = null, $data_compare_func, $key_compare_func){
        return array_uintersect_uassoc( $array1, $array2, $_, $data_compare_func, $key_compare_func);
    }
    /**
     * array_uintersect 函数 ：计算数组的交集并用回调 函数 比较数据
     * @access public
     * @return
     */
    public static function array_uintersect (array $array1, array $array2, array $_ = null, $data_compare_func){
        return array_uintersect($array1, $array2, $_ , $data_compare_func);
    }
    /**
     * array_walk_recursive 函数 ：对数组中的每个成员递归地应用用户 函数
     * @access public
     * @return
     */
    public static function array_walk_recursive (array &$input, $funcname, $userdata = null){
        return array_walk_recursive( $input, $funcname, $userdata);
    }
    /**
     * array_walk 函数 ：对数组中的每个成员应用用户 函数
     * @access public
     * @return
     */
    public static function array_walk (array &$array, $funcname, $userdata = null){
        return array_walk( $array, $funcname, $userdata);
    }
    /**
     * compact 函数 ：用变量名和值建立一个数组
     * @access public
     * @return
     */
    public static function compact ($varname, $_ = null){
        return compact( $varname, $_ );
    }
    /**
     * count 函数 ：计算数组中的单元数目或对象中的属性个数
     * @access public
     * @return
     */
    public static function count ($var, $mode = COUNT_NORMAL){
        return count( $var, $mode);
    }
    /**
     * current 函数 ：返回数组中的当前单元
     * @access public
     * @return
     */
    public static function current (array $array){
        return current($array);
    }
    /**
     * extract 函数 ：从数组中将变量导入当前的符号表中
     * @access public
     * @return
     */
    public static function extract (array $var_array, $extract_type = null, $prefix = null){
        return extract( $var_array, $extract_type , $prefix);
    }
    /**
     * in_array 函数 ：查找数组中是否存在某个值
     * @access public
     * @return
     */
    public static function in_array ($needle, array $haystack, $strict = false){
        return in_array( $needle,   $haystack, $strict  );
    }
    /**
     * key 函数 ：从关联数组中获取键名
     * @access public
     * @return
     */
    public static function key (array $array){
        return key( $array);
    }
    /**
     * list 函数 ：把数组中的值赋给一些变量
     * @access public
     * @return
     */
    public static function list ($var1, ...$_){
        return PS_UNRESERVE_PREFIX_list($var1, ...$_);
    }
    /**
     * next 函数 ：将数组中的内部指针向前移动一位
     * @access public
     * @return
     */
    public static function next (array &$array){
        return next( $array);
    }
    /**
     * prev 函数 ：将数组中的内部指针倒回一位
     * @access public
     * @return
     */
    public static function prev (array &$array){
        return prev( $array);
    }
    /**
     * reset 函数 ：将数组中的内部指针指向第一个单元
     * @access public
     * @return
     */
    public static function reset (array &$array){
        return reset( $array);
    }
    /**
     * shuffle 函数 ：打乱一个数组
     * @access public
     * @return
     */
    public static function shuffle (array &$array){
        return shuffle( $array);
    }
}